package lyfj

import (
	"encoding/json"
	"fmt"
	"log"
	//	"strconv"
	"database/sql"
	"www1/mydb"
)

var db mydb.Mydb

type LYFJ struct {
	Id       int     `json:"id"`
	Parentid int     `json:"pId"`
	Name     string  `json:"text"`
	Type_id  int     `json:"type_id"`
	Child    []*LYFJ `json:"nodes"`
}

func init() {
	db.Init()
}

func Get_lyfj_list(xm_id int) (datas []LYFJ) {
	var (
		err  error
		rows *sql.Rows
		l    LYFJ
	)
	//通过项目ID，取得此项目的楼宇房间列表切片字段
	rows, err = db.Query("select lyfj_id,lyfj_name,parentid,type_id from t1_xm_lyfj where xm_id=? ORDER BY sort ASC", xm_id)
	//判断err是否有错误的数据，有err数据就显示panic的数据
	if err != nil {
		panic(err.Error())
		fmt.Println(err.Error())
		return
	}
	defer rows.Close()
	for rows.Next() { //开始循环
		err = rows.Scan(&l.Id, &l.Name, &l.Parentid, &l.Type_id) //数据指针，会把得到的数据，往刚才id 和 lvs引入
		if err == nil {
			datas = append(datas, l)
			//fmt.Println("parentid是", l.parentid, "\t lyfj_id号是", strconv.Itoa(l.id)+"\t lvs是"+l.name) //输出来而已，看看
		}
	}
	/*
		for _, v := range datas {
			fmt.Println("parentid:", v.Parentid, "\t name:", v.Name, "\t id:", v.Id)
		}
		//转化成json
		json_data, err = json.Marshal(datas)
		if err != nil {
			log.Fatalf("JSON marshaling failed: %s", err)
		}
		log.Printf("显示转化后的json数据：%s\n", json_data)
	*/
	/*insert_sql := "INSERT INTO xiaorui(lvs) VALUES(?)"
	_, e4 := db.Exec(insert_sql, "nima")*/
	//fmt.Println(e4)
	return datas
}

func Get_lyfj_json(xm_id int) (json_data []byte) {
	/*最多取到5层数据，学校-校区-楼幢-楼层-教室*/
	/*返回根据结构树型的JSON数据*/
	var (
		data  LYFJ
		datas []LYFJ
		err   error
	)
	datas = Get_lyfj_list(xm_id)
	for _, v := range datas {
		if v.Parentid == 0 {
			data = v
		}
	}
	/*第1次循环遍历，第0层根节点取到第一层节点*/

	for _, v := range datas {
		if v.Parentid == data.Id {
			data.Child = append(data.Child, &LYFJ{v.Id, v.Parentid, v.Name, v.Type_id, v.Child})
		}
	}
	log.Printf("第1次循环遍历，第0层根节点取到第一层节点%s\n", json_data)

	/*循环遍历第一层节点，取得第一层节点的元素，即取到了第二层元素*/
	for k1, v1 := range data.Child {
		/*遍历MAP，取得第一层节点的子节点*/
		for _, v2 := range datas {
			if v2.Parentid == v1.Id {
				data.Child[k1].Child = append(data.Child[k1].Child, &LYFJ{v2.Id, v2.Parentid, v2.Name, v2.Type_id, v2.Child})
				/*下面的语句与上面的语句执行后一样能取得Child，能够表示出切片是引用类型，即v1=data.Child[k].Child
				v1.Child = append(v1.Child, &LYFJ{v2.Id, v2.Parentid, v2.Name, v2.Child})
				*/
			}
		}
	}
	log.Printf("第2次循环遍历，根节点取到第二层节点%s\n", json_data)
	/*循环遍历第二层节点，取得第二层节点的元素，即取到了第三层元素*/

	for k1, _ := range data.Child {
		for k2, v2 := range data.Child[k1].Child {
			/*遍历MAP，取得第三层元素*/
			for _, v3 := range datas {
				if v3.Parentid == v2.Id {
					data.Child[k1].Child[k2].Child = append(data.Child[k1].Child[k2].Child, &LYFJ{v3.Id, v3.Parentid, v3.Name, v3.Type_id, v3.Child})
				}
			}
		}
	}
	log.Printf("第3次循环遍历，根节点取到第三层节点%s\n", json_data)
	/*循环遍历第三层节点，取得第三层节点的元素，即取到了第四层元素*/
	for _, v1 := range data.Child {
		for _, v2 := range v1.Child {
			for _, v3 := range v2.Child {
				/*遍历MAP，取得第四层元素*/
				for _, v4 := range datas {
					if v4.Parentid == v3.Id {
						v3.Child = append(v3.Child, &LYFJ{v4.Id, v4.Parentid, v4.Name, v4.Type_id, v4.Child})
					}
				}
			}
		}
	}
	log.Printf("第4次循环遍历，根节点取到第四层节点%s\n", json_data)
	json_data, err = json.MarshalIndent(data, "", "  ") //json.Marshal(data)
	if err != nil {
		log.Panicf("JSON marshaling failed: %s", err)
	}
	log.Printf("%s\n", json_data)
	return json_data
}
